{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "import numpy as np\n",
    "import mindspore.dataset as ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data_path = '../datasets/MNIST_Data/train'\n",
    "test_data_path = '../dataset/MNIST_Data/test'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mindspore.dataset.vision.c_transforms as CV\n",
    "import mindspore.dataset.transforms.c_transforms as C\n",
    "from mindspore.dataset.vision import Inter\n",
    "from mindspore import dtype as mstype\n",
    "import mindspore.nn as nn\n",
    "from mindspore.common.initializer import Normal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_dataset(data_path, batch_size=32, repeat_size=1,\n",
    "                   num_parallel_workers=8):\n",
    "    \"\"\"\n",
    "    create dataset for train or test\n",
    "\n",
    "    Args:\n",
    "        data_path (str): Data path\n",
    "        batch_size (int): The number of data records in each group\n",
    "        repeat_size (int): The number of replicated data records\n",
    "        num_parallel_workers (int): The number of parallel workers\n",
    "    \"\"\"\n",
    "    # define dataset\n",
    "    mnist_ds = ds.MnistDataset(data_path)\n",
    "\n",
    "    # define some parameters needed for data enhancement and rough justification\n",
    "    resize_height, resize_width = 32, 32\n",
    "    rescale = 1.0 / 255.0\n",
    "    shift = 0.0\n",
    "    rescale_nml = 1 / 0.3081\n",
    "    shift_nml = -1 * 0.1307 / 0.3081\n",
    "\n",
    "    # according to the parameters, generate the corresponding data enhancement method\n",
    "    resize_op = CV.Resize((resize_height, resize_width), interpolation=Inter.LINEAR)\n",
    "    rescale_nml_op = CV.Rescale(rescale_nml, shift_nml)\n",
    "    rescale_op = CV.Rescale(rescale, shift)\n",
    "    hwc2chw_op = CV.HWC2CHW()\n",
    "    type_cast_op = C.TypeCast(mstype.int32)\n",
    "\n",
    "    # using map to apply operations to a dataset\n",
    "    mnist_ds = mnist_ds.map(operations=type_cast_op, input_columns=\"label\", num_parallel_workers=num_parallel_workers)\n",
    "    mnist_ds = mnist_ds.map(operations=resize_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n",
    "    mnist_ds = mnist_ds.map(operations=rescale_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n",
    "    mnist_ds = mnist_ds.map(operations=rescale_nml_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n",
    "    mnist_ds = mnist_ds.map(operations=hwc2chw_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n",
    "\n",
    "    # process the generated dataset\n",
    "    buffer_size = 10000\n",
    "    mnist_ds = mnist_ds.shuffle(buffer_size=buffer_size)\n",
    "    mnist_ds = mnist_ds.batch(batch_size, drop_remainder=True)\n",
    "    mnist_ds = mnist_ds.repeat(repeat_size)\n",
    "\n",
    "    return mnist_ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "ms_dataset = create_dataset(train_data_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor of image: (32, 1, 32, 32)\n",
      "Labels: [4 0 4 5 3 3 0 1 6 2 5 6 2 9 1 1 7 7 8 2 7 9 1 6 8 6 4 8 8 8 1 9]\n"
     ]
    }
   ],
   "source": [
    "data = next(ms_dataset.create_dict_iterator(output_numpy=True))\n",
    "images = data[\"image\"]\n",
    "labels = data[\"label\"]\n",
    "print('Tensor of image:', images.shape)\n",
    "print('Labels:', labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LeNet5(nn.Cell):\n",
    "    \"\"\"Lenet network structure.\"\"\"\n",
    "    # define the operator required\n",
    "    def __init__(self, num_class=10, num_channel=1):\n",
    "        super(LeNet5, self).__init__()\n",
    "        # 卷积核大小5*5，卷积核种类6，输入通道为1\n",
    "        self.conv1 = nn.Conv2d(num_channel, 6, 5, pad_mode='valid')\n",
    "        self.max_pool2d1 = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')\n",
    "        self.max_pool2d2 = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.fc1 = nn.Dense(400, 120, weight_init=Normal(0.02))\n",
    "        self.fc2 = nn.Dense(120, 84, weight_init=Normal(0.02))\n",
    "        self.fc3 = nn.Dense(84, num_class, weight_init=Normal(0.02))\n",
    "        self.relu = nn.ReLU()\n",
    "\n",
    "    # use the preceding operators to construct networks\n",
    "    def construct(self, x):\n",
    "        x = self.max_pool2d1(self.relu(self.conv1(x)))\n",
    "        x = self.max_pool2d2(self.relu(self.conv2(x)))\n",
    "        x = self.flatten(x)\n",
    "        x = self.relu(self.fc1(x))\n",
    "        x = self.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "network = LeNet5()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mindspore.train.callback import Callback\n",
    "\n",
    "class StepLossAccInfo(Callback):\n",
    "    def __init__(self, model, eval_dataset, steps_loss, steps_eval):\n",
    "        self.model = model\n",
    "        self.eval_dataset = eval_dataset\n",
    "        self.steps_loss = steps_loss\n",
    "        self.steps_eval = steps_eval\n",
    "        \n",
    "    def step_end(self, run_context):\n",
    "        cb_params = run_context.original_args()\n",
    "        cur_epoch = cb_params.cur_epoch_num\n",
    "        cur_step = (cur_epoch-1)*1875 + cb_params.cur_step_num\n",
    "        self.steps_loss[\"loss_value\"].append(str(cb_params.net_outputs))\n",
    "        self.steps_loss[\"step\"].append(str(cur_step))\n",
    "        if cur_step % 125 == 0:\n",
    "            acc = self.model.eval(self.eval_dataset, dataset_sink_mode=False)\n",
    "            self.steps_eval[\"step\"].append(cur_step)\n",
    "            self.steps_eval[\"acc\"].append(acc[\"Accuracy\"])    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from mindspore import Tensor, Model\n",
    "from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor\n",
    "from mindspore.nn import Accuracy\n",
    "import mindspore.nn as nn\n",
    "from mindspore.nn import SoftmaxCrossEntropyWithLogits\n",
    "from mindspore import context"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "context.set_context(mode=context.GRAPH_MODE, device_target='CPU')\n",
    "lr = 0.01\n",
    "momentum = 0.9\n",
    "\n",
    "# create the network\n",
    "network = LeNet5()\n",
    "# define the optimizer\n",
    "# net_opt = nn.Adam(network.trainable_params())\n",
    "net_opt = nn.Momentum(network.trainable_params(), lr, momentum)\n",
    "\n",
    "# define the loss function\n",
    "net_loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "epoch_size = 1\n",
    "mnist_path = \"../datasets/MNIST_Data\"\n",
    "model_path = \"./models/lenet/\"\n",
    "\n",
    "repeat_size = 1\n",
    "ds_train = create_dataset(os.path.join(mnist_path, \"train\"), 32, repeat_size)\n",
    "eval_dataset = create_dataset(os.path.join(mnist_path, \"test\"), 32)\n",
    "\n",
    "# clean up old run files before in Linux\n",
    "os.system('rm -f {0}*.ckpt {0}*.meta {0}*.pb'.format(model_path))\n",
    "\n",
    "# define the model\n",
    "model = Model(network, net_loss, net_opt, metrics={\"Accuracy\": Accuracy()} )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 1 step: 125, loss is 2.3081036\n",
      "epoch: 1 step: 250, loss is 2.2862532\n",
      "epoch: 1 step: 375, loss is 2.295327\n",
      "epoch: 1 step: 500, loss is 2.2856777\n",
      "epoch: 1 step: 625, loss is 2.3160903\n",
      "epoch: 1 step: 750, loss is 2.2850957\n",
      "epoch: 1 step: 875, loss is 2.3201666\n",
      "epoch: 1 step: 1000, loss is 0.7075813\n",
      "epoch: 1 step: 1125, loss is 0.5959907\n",
      "epoch: 1 step: 1250, loss is 0.23731449\n",
      "epoch: 1 step: 1375, loss is 0.26565456\n",
      "epoch: 1 step: 1500, loss is 0.17517422\n",
      "epoch: 1 step: 1625, loss is 0.299496\n",
      "epoch: 1 step: 1750, loss is 0.024585718\n",
      "epoch: 1 step: 1875, loss is 0.17125703\n",
      "epoch: 2 step: 125, loss is 0.11809586\n",
      "epoch: 2 step: 250, loss is 0.047309447\n",
      "epoch: 2 step: 375, loss is 0.014269128\n",
      "epoch: 2 step: 500, loss is 0.09851865\n",
      "epoch: 2 step: 625, loss is 0.041767996\n",
      "epoch: 2 step: 750, loss is 0.049731705\n",
      "epoch: 2 step: 875, loss is 0.115232795\n",
      "epoch: 2 step: 1000, loss is 0.109876804\n",
      "epoch: 2 step: 1125, loss is 0.031761877\n",
      "epoch: 2 step: 1250, loss is 0.0075117103\n",
      "epoch: 2 step: 1375, loss is 0.013591048\n",
      "epoch: 2 step: 1500, loss is 0.030217158\n",
      "epoch: 2 step: 1625, loss is 0.06412532\n",
      "epoch: 2 step: 1750, loss is 0.007894291\n",
      "epoch: 2 step: 1875, loss is 0.008877255\n",
      "epoch: 3 step: 125, loss is 0.29581228\n",
      "epoch: 3 step: 250, loss is 0.08421001\n",
      "epoch: 3 step: 375, loss is 0.0022359907\n",
      "epoch: 3 step: 500, loss is 0.14058624\n",
      "epoch: 3 step: 625, loss is 0.06464292\n",
      "epoch: 3 step: 750, loss is 0.050966255\n",
      "epoch: 3 step: 875, loss is 0.003283576\n",
      "epoch: 3 step: 1000, loss is 0.11848585\n",
      "epoch: 3 step: 1125, loss is 0.035597224\n",
      "epoch: 3 step: 1250, loss is 0.056464113\n",
      "epoch: 3 step: 1375, loss is 0.21061234\n",
      "epoch: 3 step: 1500, loss is 0.047847405\n",
      "epoch: 3 step: 1625, loss is 0.03146019\n",
      "epoch: 3 step: 1750, loss is 0.08977585\n",
      "epoch: 3 step: 1875, loss is 0.07656989\n",
      "epoch: 4 step: 125, loss is 0.006778006\n",
      "epoch: 4 step: 250, loss is 0.10339911\n",
      "epoch: 4 step: 375, loss is 0.0109065\n",
      "epoch: 4 step: 500, loss is 0.33718643\n",
      "epoch: 4 step: 625, loss is 0.025020787\n",
      "epoch: 4 step: 750, loss is 0.096578345\n",
      "epoch: 4 step: 875, loss is 0.005642332\n",
      "epoch: 4 step: 1000, loss is 0.0029155882\n",
      "epoch: 4 step: 1125, loss is 0.09979\n",
      "epoch: 4 step: 1250, loss is 0.1350897\n",
      "epoch: 4 step: 1375, loss is 0.028854378\n",
      "epoch: 4 step: 1500, loss is 0.0011959556\n",
      "epoch: 4 step: 1625, loss is 0.012746576\n",
      "epoch: 4 step: 1750, loss is 0.0051864716\n",
      "epoch: 4 step: 1875, loss is 0.1516218\n",
      "epoch: 5 step: 125, loss is 0.16674203\n",
      "epoch: 5 step: 250, loss is 0.004783524\n",
      "epoch: 5 step: 375, loss is 0.007019765\n",
      "epoch: 5 step: 500, loss is 0.09520198\n",
      "epoch: 5 step: 625, loss is 0.020969167\n",
      "epoch: 5 step: 750, loss is 0.0031775704\n",
      "epoch: 5 step: 875, loss is 0.008753059\n",
      "epoch: 5 step: 1000, loss is 0.004086743\n",
      "epoch: 5 step: 1125, loss is 0.05310721\n",
      "epoch: 5 step: 1250, loss is 0.11995046\n",
      "epoch: 5 step: 1375, loss is 0.008280059\n",
      "epoch: 5 step: 1500, loss is 0.009514566\n",
      "epoch: 5 step: 1625, loss is 0.020766456\n",
      "epoch: 5 step: 1750, loss is 0.030191042\n",
      "epoch: 5 step: 1875, loss is 0.0035973766\n"
     ]
    }
   ],
   "source": [
    "# save the network model and parameters for subsequence fine-tuning\n",
    "config_ck = CheckpointConfig(save_checkpoint_steps=375, keep_checkpoint_max=5)\n",
    "# group layers into an object with training and evaluation features\n",
    "ckpoint_cb = ModelCheckpoint(prefix=\"checkpoint_lenet\", directory=model_path, config=config_ck)\n",
    "\n",
    "steps_loss = {\"step\": [], \"loss_value\": []}\n",
    "steps_eval = {\"step\": [], \"acc\": []}\n",
    "# collect the steps,loss and accuracy information\n",
    "step_loss_acc_info = StepLossAccInfo(model , eval_dataset, steps_loss, steps_eval)\n",
    "\n",
    "model.train(5, ds_train, callbacks=[ckpoint_cb, LossMonitor(125), step_loss_acc_info], dataset_sink_mode=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'./models/lenet/'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "steps = steps_loss[\"step\"]\n",
    "loss_value = steps_loss[\"loss_value\"]\n",
    "steps = list(map(int, steps))\n",
    "loss_value = list(map(float, loss_value))\n",
    "plt.plot(steps, loss_value, color=\"red\")\n",
    "plt.xlabel(\"Steps\")\n",
    "plt.ylabel(\"Loss_value\")\n",
    "plt.title(\"Change chart of model loss value\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============== Starting Testing ==============\n",
      "============== Accuracy:{'Accuracy': 0.9662459935897436} ==============\n"
     ]
    }
   ],
   "source": [
    "from mindspore import load_checkpoint, load_param_into_net\n",
    "\n",
    "# testing relate modules\n",
    "def test_net(network, model, mnist_path):\n",
    "    \"\"\"Define the evaluation method.\"\"\"\n",
    "    print(\"============== Starting Testing ==============\")\n",
    "    # load the saved model for evaluation\n",
    "    param_dict = load_checkpoint(model_path+\"/checkpoint_lenet-1_1875.ckpt\")\n",
    "    # load parameter to the network\n",
    "    load_param_into_net(network, param_dict)\n",
    "    # load testing dataset\n",
    "    ds_eval = create_dataset(os.path.join(mnist_path, \"test\"))\n",
    "    acc = model.eval(ds_eval, dataset_sink_mode=False)\n",
    "    print(\"============== Accuracy:{} ==============\".format(acc))\n",
    "\n",
    "test_net(network, model, mnist_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def eval_show(steps_eval):\n",
    "    plt.xlabel(\"step number\")\n",
    "    plt.ylabel(\"Model accuracy\")\n",
    "    plt.title(\"Model accuracy variation chart\")\n",
    "    plt.plot(steps_eval[\"step\"], steps_eval[\"acc\"], \"red\")\n",
    "    plt.show()\n",
    "\n",
    "eval_show(steps_eval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'model' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-4-54a1794a433f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mlabels\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"label\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0masnumpy\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0moutput\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mTensor\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'image'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      5\u001b[0m \u001b[0mpred\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0margmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0masnumpy\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[0merr_num\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'model' is not defined"
     ]
    }
   ],
   "source": [
    "images = data[\"image\"].asnumpy()\n",
    "labels = data[\"label\"].asnumpy()\n",
    "\n",
    "output = model.predict(Tensor(data['image']))\n",
    "pred = np.argmax(output.asnumpy(), axis=1)\n",
    "err_num = []\n",
    "index = 1\n",
    "for i in range(len(labels)):\n",
    "    plt.subplot(4, 8, i+1)\n",
    "    color = 'blue' if pred[i] == labels[i] else 'red'\n",
    "    plt.title(\"pre:{}\".format(pred[i]), color=color)\n",
    "    plt.imshow(np.squeeze(images[i]))\n",
    "    plt.axis(\"off\")\n",
    "    if color == 'red':\n",
    "        index = 0\n",
    "        print(\"Row {}, column {} is incorrectly identified as {}, the correct value should be {}\".format(int(i/8)+1, i%8+1, pred[i], labels[i]), '\\n')\n",
    "if index:\n",
    "    print(\"All the figures in this group are predicted correctly!\")\n",
    "print(pred, \"<--Predicted figures\")\n",
    "print(labels, \"<--The right number\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "from net.LeNet import LeNet5, LeNet5_padding\n",
    "from net.utils import *\n",
    "from dataset.preprocess import *\n",
    "from pipecoco.common import *\n",
    "\n",
    "from mindspore.nn import SoftmaxCrossEntropyWithLogits\n",
    "from mindspore.nn import Accuracy\n",
    "from pipecoco.PipeCoCo import PipeCoCo\n",
    "from mindspore import context\n",
    "\n",
    "context.set_context(mode=context.GRAPH_MODE, device_target='CPU')\n",
    "\n",
    "mnist_path = \"../datasets/MNIST_Data\"\n",
    "model_path = \"./models/lenet_padding/\"\n",
    "network = LeNet5_padding()\n",
    "\n",
    "# model_path = \"./models/lenet/\"\n",
    "# network = LeNet5()\n",
    "\n",
    "load_model(network, model_path+\"/checkpoint_lenet-5_1875.ckpt\")\n",
    "\n",
    "\n",
    "net_loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')\n",
    "\n",
    "ds_eval = create_dataset(os.path.join(mnist_path, \"test\"))\n",
    "# eval(network, model_path+\"/checkpoint_lenet-5_1875.ckpt\", net_loss, ds_eval)\n",
    "\n",
    "layers_list = []\n",
    "dfs_search_layers(network, layers_list)\n",
    "pipecoco_model = PipeCoCo(layers_list, [1 ,32, 32])\n",
    "\n",
    "ds_test = ds_eval.create_dict_iterator()\n",
    "data = next(ds_test)\n",
    "input = data[\"image\"].asnumpy()\n",
    "x = pipecoco_model.forward(input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 8 8 3 4 1 1 6 1 1 5 3 6 7 7 4 6 7 5 4 4 6 8 1 9 7 4 1 0 8 1 7]\n",
      "Row 2, column 5 is incorrectly identified as 6, the correct value should be 5 \n",
      "\n",
      "Row 3, column 6 is incorrectly identified as 6, the correct value should be 5 \n",
      "\n",
      "[1 8 8 3 4 1 1 6 1 1 5 3 6 7 7 4 6 7 5 4 4 6 8 1 9 7 4 1 0 8 1 7] <--Predicted figures\n",
      "[1 8 8 3 4 1 1 6 1 1 5 3 5 7 7 4 6 7 5 4 4 5 8 1 9 7 4 1 0 8 1 7] <--The right number\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 32 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "images = data[\"image\"].asnumpy()\n",
    "labels = data[\"label\"].asnumpy()\n",
    "\n",
    "pred = np.argmax(x.asnumpy(), axis=1)\n",
    "print(pred)\n",
    "\n",
    "err_num = []\n",
    "index = 1\n",
    "for i in range(len(labels)):\n",
    "    plt.subplot(4, 8, i+1)\n",
    "    color = 'blue' if pred[i] == labels[i] else 'red'\n",
    "    plt.title(\"pre:{}\".format(pred[i]), color=color)\n",
    "    plt.imshow(np.squeeze(images[i]))\n",
    "    plt.axis(\"off\")\n",
    "    if color == 'red':\n",
    "        index = 0\n",
    "        print(\"Row {}, column {} is incorrectly identified as {}, the correct value should be {}\".format(int(i/8)+1, i%8+1, pred[i], labels[i]), '\\n')\n",
    "if index:\n",
    "    print(\"All the figures in this group are predicted correctly!\")\n",
    "print(pred, \"<--Predicted figures\")\n",
    "print(labels, \"<--The right number\")\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "mindspore",
   "language": "python",
   "name": "mindspore"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
